home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1997 September / Macworld (1997-09).dmg / Serious Software / Cherwell Scientific Demos / pro Fit / pro Fit 5.0 demo (fpu).sea / pro Fit 5.0 demo (fpu) / External Modules / External modules sources / C / proFit_paramBlk.h < prev    next >
Text File  |  1995-12-25  |  7KB  |  151 lines
  1. /***************************************************************************************/
  2. /* proFit_paramBlk.h                                                                   */
  3. /*                                                                                        */
  4. /*                                                                                     */
  5. /* Version 21.11.95                                                                     */
  6. /***************************************************************************************/
  7.  
  8.  
  9. /******************************************************************************************
  10. This file contains interface information that defines the communication between
  11. an External Module and pro Fit. This information is used by pro Fit_interface.c
  12. to provide the code that implements all of the predifined routines made
  13. available by pro Fit.
  14.  
  15. Normally, you will just want to leave these file untouched in your external
  16. module folder, and to never have a look at it.
  17.  
  18.  
  19.  
  20.                             ************************
  21.                             
  22. You need the folloing information if you want to program a very advanced
  23. external module, and if you want to do more exotic things.
  24.  
  25. All the interaction between pro Fit and the external module takes place through the procedure main.
  26. pro Fit calls it with different values of its parameter 'selector' and the
  27. function main must return the information requested by setting the necessary fields
  28. inside a parameterBlock.
  29.  
  30. When it first opens the external module, pro Fit calls main with the selector equal to zero, and
  31. main must provide the specifications of the code supplied, such as the settings
  32. with which the code was compiled, if the code is a function or a program, the name of the
  33. external module, etc.
  34.  
  35. Depending on the response it obtains after calling the external module with selector 0, pro Fit
  36. then calls it with the selector that tells the module to initialize some parameters. This is
  37. very simple for programs, but there are a few more things to be set for functions.
  38.  
  39. After the module is added to pro Fit's menus pro Fit calls it with the selector
  40. identifying the action needed and pro Fit will expect the external module to react accordingly.
  41. For programs, pro Fit calls the external module with only one selector, the one identifying
  42. the function run().
  43. For functions, pro Fit calls the external module with a range of selectors, identifying the
  44. functions check, first, last, and so on. If you do not want to define such functionality, simply
  45. leave these function empty.
  46.  
  47. See the files FunctionTemplate.c and ProgramTemplate.c
  48. *****************************************************************************************/
  49.  
  50. #ifndef __PROFIT_PARAMBLK__
  51. #define __PROFIT_PARAMBLK__
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59. /*     The following struct is used as a parameterBlock when pro Fit calls an external module.
  60.     The external module must provide a function main(short selector, ExtModulesParamBlock* pb).
  61.     When pro Fit interacts with the external module, it calls main with various values of the 
  62.     first parameter. Depending on the value of selector the function main must give the
  63.     right response, i.e act as the function first, or calculate the y-value or your
  64.     functions, and so on. The parameterblock contains all the information you will ever need
  65.     to do this.
  66.         
  67.     The file pro Fit_interface.c provides a predifined function main that performes all the necessary
  68.     calls, with the right parameters, to a set of functions called, as you might expect,
  69.     first, check, derivatives, run, etc. These functions correspond exactly to the functions you
  70.     define when defining functions and programs within pro Fit.
  71.     
  72.     All you need to do is fill them in according to your needes.
  73.     
  74.     Unless you want to produce some advanced, exotic functionality in your external module, you
  75.     do not need to access the parameterblock directly.
  76. */
  77.  
  78. enum {CPU68noFPU=1, CPU68FPU, CPUPowerPC};    /* The type of code generated. */
  79. enum {    setup=0,                            
  80.         progInitialize=11,progRun,
  81.         funcInitialize=21,funcCheck,funcFirst,funcFunc,funcDerivatives,funcLast,
  82.         cleanUp=31
  83.      };                                     /* possible values of selector */
  84.  
  85.  
  86. #if defined(powerc) || defined (__powerc)
  87. #pragma options align=mac68k
  88. #endif
  89. typedef struct {
  90.           pascal void (*RunTimeProc) (void* pb);        /* the parameter is of type "RunTimeParamRec*" */
  91.               /* call back routine for pro Fit        */
  92.               /* the external module uses this bottleneck to call all routines     */
  93.               /* provided by pro Fit */
  94.           
  95.         Ptr            globals;     /* global variable space (defined if selector>0) */
  96.                                 /* and if requiredGlobals was set >0 in SetUp. */
  97.  
  98.         /* parameters to be set when selector==setup==0 */
  99.         short     versionNumber;    /* the present implementation */
  100.         short     moduleKind;     /* {isFunction, isProgram, isMacro} */
  101.         short   codeType;        /* {CPU68noFPU=1, CPU68FPU, CPUPowerPC} */
  102.         Str255  name;            /* the name of your external module */
  103.         long    requiredGlobals;/* global memory required. If this is >0 pro Fit allocates the         */
  104.                                 /* required memory and returns a pointer to it in the pointer         */
  105.                                 /* "globals". Do not touch the pointer value. pro Fit is responsible */
  106.                                 /* for allocating AND deallocating it.     */
  107.  
  108.         /* general info provided by pro Fit */
  109.         double     v[30];             /* an array for general purpose use in the external module */
  110.  
  111.  
  112.     /* the following entries can only be used by functions.     */
  113.     /* they can be accessed only when selector>0 and when         */
  114.     /* moduleKind==isFunction. moduleKind must be set in SetUp, when the external module */
  115.     /* is called for the first time (with selector==0)     */
  116.         
  117.         /* parameters to be set by funcInitialize */
  118.         Boolean         dummy;            /*unused */
  119.         Boolean         hasDerivatives;    /* true if proFit must call the function "Derivatives" defined in your module   */
  120.                                         /* You can set this paramter to true, and only calculate a few derivatives (dyda[] values) */
  121.                                         /* in your "Derivatives" function. pro Fit will take care of calculating the rest numerically. */
  122.                                         /* If you set this hasDerivatives to true and leave your definition of "Derivatives" empty, then */
  123.                                         /* you have the same result obtained when setting hasDerivatives to false: proFit calculates all */
  124.                                         /* derivatives numerically.            */
  125.         Str255            descr1,descr2;    /* description to appear in parameters window  */
  126.         short            numberOfParams;    /* number of parameters used by the function  */
  127.         DefaultParamInfo a0;            /* all parameter default settings.  */
  128.  
  129.         /*parameters used in check*/
  130.         short             paramNo;        /* current parm number, for check             */
  131.         short             answer;            /* return value of check, type CheckPAnswer */
  132.         
  133.         /*parameters used in func and in derivatives. */
  134.         double*         x;                /* x value */
  135.         double*          y;                 /* y value, return value of a function. */
  136.         ParamArray*        a;                /* parameter values, set to a0.value before calling first. */
  137.         ParamArray*        dyda;            /* used by derivatives, set to the derivatives of the function with respect to its parameters. */
  138.                                         /* If a dyda[] value is not set, pro Fit calculates that derivative numerically. */
  139.         /*pointer to the global scratch */
  140.         GlobalScratch*    globalScratch;    /* global data to be acessed by all modules */        
  141.         FSSpec            moduleFile;        /* the file where this external module is in */
  142.  
  143.   } ExtModulesParamBlock;
  144. #if defined(powerc) || defined (__powerc)
  145. #pragma options align=reset
  146. #endif
  147.  
  148.  
  149.  
  150. #endif
  151.